perf(profiling): consolidate greenlet switch updates - #19655

Description

Consolidates the two native frame updates performed for each greenlet switch into one private record_greenlet_switch() call and one greenlet_info_map mutex acquisition.

The existing behavior is preserved: the origin frame is always updated, while the running target frame is left unchanged when it is needed for parent-greenlet stack unwinding.

This is an independently mergeable prerequisite extracted from #18724.

Testing

• scripts/lint fmt -- ddtrace/profiling/_gevent.py tests/profiling/test_gevent.py tests/profiling/collector/test_stack.py
• scripts/lint cformat
• scripts/lint profiling-native-check
• scripts/lint checks
• git diff --check
• Fresh CPython 3.12 native extension build
• Native linked-parent switch regression covering preserved and updated target frames
• Existing high-cardinality greenlet switch contention regression

Benchmark

The benchmark isolates the native operation changed by this PR. Each measured run performs 1,000,000 logical greenlet switch updates after 10,000 warm-up updates:

• baseline e11d640110: two update_greenlet_frame() native calls and two mutex acquisitions per update
• candidate 93702898f8: one record_greenlet_switch() native call and one mutex acquisition per update

Both _stack extensions were built in Release mode from the exact commits, then run in the same container pinned to CPU 0 with --cpuset-cpus=0.

Results over five runs:

• before: 0.531681 seconds median, runs [0.528339, 0.531681, 0.532128, 0.534566, 0.529234]
• after: 0.366206 seconds median, runs [0.380415, 0.368066, 0.360803, 0.362898, 0.366206]
• change: approximately 31% faster for the isolated native update

Environment:

• AWS KVM VM, Intel Xeon Platinum 8175M at 2.50 GHz
• 16 vCPUs, 8 cores with 2 threads per core, 61 GiB RAM
• Linux 6.8.0-1055-aws, x86-64
• Docker server 29.5.2, container pinned to one CPU
• CPython 3.12.13, GCC 14.2.0, glibc 2.41
• container image sha256:ce7c46dbb7f07d352aecd756e19fd7f39550a72d4a13e68d30f02f5448eebd69

import statistics
import time

from ddtrace.internal.datadog.profiling import stack


ITERATIONS = 1_000_000
RUNS = 5
ORIGIN_ID = 101
TARGET_ID = 102

stack.track_greenlet(ORIGIN_ID, "origin", False)
stack.track_greenlet(TARGET_ID, "target", False)

if hasattr(stack, "record_greenlet_switch"):

    def update():
        stack.record_greenlet_switch(ORIGIN_ID, False, TARGET_ID, None, True)

else:

    def update():
        stack.update_greenlet_frame(ORIGIN_ID, False)
        stack.update_greenlet_frame(TARGET_ID, None)


def run_once():
    start = time.perf_counter()
    for _ in range(ITERATIONS):
        update()
    return time.perf_counter() - start


for _ in range(10_000):
    update()
runs = [run_once() for _ in range(RUNS)]

stack.untrack_greenlet(ORIGIN_ID)
stack.untrack_greenlet(TARGET_ID)

print(f"median={statistics.median(runs):.6f}s runs={runs}")

This is an isolated native-call benchmark, not an end-to-end application throughput claim. The earlier 67% figure was discarded after reproducing with exact baseline and candidate builds because the candidate run had not activated the profiling hook.

Risks

Low. The changed Python and native APIs are private and ship together. Existing parent-greenlet frame retention remains unchanged.

Additional Notes

The GIL release around native state mutation is retained intentionally. It was introduced by #14852 in commit 54a3a0ea35 to prevent potential thread-pool deadlocks while waiting for profiler mutexes. This change reduces two such release windows per greenlet switch to one.

No release note is needed because this is an internal performance optimization with no user-facing API or behavior change.